{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "6f5bb572",
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "from sklearn.model_selection import train_test_split\n",
    "import random\n",
    "import time\n",
    "from cvxopt import spmatrix\n",
    "import heapq\n",
    "import math"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "130c167c",
   "metadata": {},
   "outputs": [],
   "source": [
    "df=pd.read_csv('E:/推荐系统/数据集/MovieLens/ml-latest/ratings.csv')\n",
    "df_copy1=df.copy()     #正负反馈皆有\n",
    "df_copy2=df.copy()      \n",
    "df_copy2=df_copy1[df_copy1['rating']>2.9]     #只有正反馈"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "04a28db7",
   "metadata": {},
   "outputs": [],
   "source": [
    "df=df_copy2.iloc[:50000].sample(frac=1)[['userId','movieId']]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "ca1ead78",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>userId</th>\n",
       "      <th>movieId</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>51658</th>\n",
       "      <td>507</td>\n",
       "      <td>1080</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>26749</th>\n",
       "      <td>248</td>\n",
       "      <td>3698</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2994</th>\n",
       "      <td>42</td>\n",
       "      <td>8961</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>28562</th>\n",
       "      <td>267</td>\n",
       "      <td>1438</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>20086</th>\n",
       "      <td>206</td>\n",
       "      <td>2354</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>...</th>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2532</th>\n",
       "      <td>38</td>\n",
       "      <td>353</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5614</th>\n",
       "      <td>59</td>\n",
       "      <td>520</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>11506</th>\n",
       "      <td>119</td>\n",
       "      <td>69438</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>59999</th>\n",
       "      <td>593</td>\n",
       "      <td>3448</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>19916</th>\n",
       "      <td>197</td>\n",
       "      <td>106782</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>50000 rows × 2 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "       userId  movieId\n",
       "51658     507     1080\n",
       "26749     248     3698\n",
       "2994       42     8961\n",
       "28562     267     1438\n",
       "20086     206     2354\n",
       "...       ...      ...\n",
       "2532       38      353\n",
       "5614       59      520\n",
       "11506     119    69438\n",
       "59999     593     3448\n",
       "19916     197   106782\n",
       "\n",
       "[50000 rows x 2 columns]"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "00263dce",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "数据集中的电影部数：7142\n",
      "数据集中的用户数：597\n"
     ]
    }
   ],
   "source": [
    "print(\"数据集中的电影部数：%d\"%len(df['movieId'].unique()))\n",
    "print(\"数据集中的用户数：%d\"%len(df['userId'].unique()))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "6c055a8b",
   "metadata": {},
   "outputs": [],
   "source": [
    "#按比例划分训练集和测试集\n",
    "proportion=0.8\n",
    "train=df.iloc[0:int(proportion*df.shape[0])]\n",
    "test=df.iloc[int(proportion*df.shape[0]):]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "af2c7b04",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\dell\\AppData\\Local\\Temp/ipykernel_16956/3039420440.py:2: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  train['popularity']=1\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>movieId</th>\n",
       "      <th>popularity</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1</td>\n",
       "      <td>109</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>2</td>\n",
       "      <td>30</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>3</td>\n",
       "      <td>20</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>4</td>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>5</td>\n",
       "      <td>18</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>...</th>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6530</th>\n",
       "      <td>188309</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6531</th>\n",
       "      <td>189333</td>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6532</th>\n",
       "      <td>189363</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6533</th>\n",
       "      <td>190017</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6534</th>\n",
       "      <td>192081</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>6535 rows × 2 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "      movieId  popularity\n",
       "0           1         109\n",
       "1           2          30\n",
       "2           3          20\n",
       "3           4           3\n",
       "4           5          18\n",
       "...       ...         ...\n",
       "6530   188309           1\n",
       "6531   189333           2\n",
       "6532   189363           1\n",
       "6533   190017           1\n",
       "6534   192081           1\n",
       "\n",
       "[6535 rows x 2 columns]"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#物品流行度计算\n",
    "train['popularity']=1\n",
    "df_movie_popularity=train.groupby('movieId').agg('sum').reset_index()\n",
    "df_movie_popularity=df_movie_popularity[['movieId','popularity']]\n",
    "df_movie_popularity"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "b6a48343",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "程序用时：447.276805秒\n"
     ]
    }
   ],
   "source": [
    "#计算用户兴趣相似度矩阵W\n",
    "start=time.time()\n",
    "\n",
    "C={}\n",
    "N={}\n",
    "for name, result in train.groupby('movieId'):\n",
    "    reslt=pd.DataFrame(result)\n",
    "    for j in range(result.shape[0]):\n",
    "        if result.iloc[j]['userId'] not in N:\n",
    "            N[result.iloc[j]['userId']]=0\n",
    "        N[result.iloc[j]['userId']]+=1\n",
    "        for k in range(j+1,result.shape[0]):\n",
    "          \n",
    "            if result.iloc[k]['userId']==result.iloc[j]['userId']:\n",
    "                continue\n",
    "            else:\n",
    "                if (result.iloc[j]['userId'],result.iloc[k]['userId']) not in C:\n",
    "                    C[result.iloc[j]['userId'],result.iloc[k]['userId']]=0\n",
    "                #改动\n",
    "                if (result.iloc[k]['userId'],result.iloc[j]['userId']) not in C:\n",
    "                    C[result.iloc[k]['userId'],result.iloc[j]['userId']]=0\n",
    "                    \n",
    "                C[result.iloc[j]['userId'],result.iloc[k]['userId']]+=1/math.log(1+result.shape[0])\n",
    "                C[result.iloc[k]['userId'],result.iloc[j]['userId']]+=1/math.log(1+result.shape[0])\n",
    "W={}\n",
    "for key in C:\n",
    "    Nu=N[key[0]]\n",
    "    Nv=N[key[1]]\n",
    "    W[key]=C[key]/(math.sqrt(Nu)*math.sqrt(Nv))\n",
    "\n",
    "            \n",
    "end=time.time()    \n",
    "print(\"程序用时：%f秒\"%(end-start))    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "f4d299d5",
   "metadata": {},
   "outputs": [],
   "source": [
    "#提取出具有相同兴趣的每一对用户及他们的兴趣相似度\n",
    "user1_lst=[]\n",
    "user2_lst=[]\n",
    "for key in W.keys():\n",
    "    \n",
    "    user1_lst.append(key[0])\n",
    "    user2_lst.append(key[1])\n",
    "\n",
    "df_W=pd.DataFrame({'user1':user1_lst,\n",
    "                   'user2':user2_lst,\n",
    "                   'relevance':list(W.values())})\n",
    "df_W.columns=('user1','user2','relevance')\n",
    "\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "7c1b8f7d",
   "metadata": {},
   "outputs": [],
   "source": [
    "df_W=pd.read_csv('E:/推荐系统/代码/中间量/User_based-CF_movielens中等数据集（部分）.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "bb540357",
   "metadata": {},
   "outputs": [],
   "source": [
    "#对W矩阵的行进行归一化，即基于user1进行groupby，找出user1对应的行，然后对user2进行归一化\n",
    "df_W_normalization=pd.DataFrame(columns=['user1','user2','relevance'])\n",
    "for user1, result in df_W.groupby('user1'):\n",
    "    result=result.reset_index(drop=True)\n",
    "    result['relevance']=result['relevance']/max(result['relevance'])\n",
    "    df_W_normalization=pd.concat([df_W_normalization,result])\n",
    "    \n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "27952f92",
   "metadata": {},
   "outputs": [],
   "source": [
    "df_W=df_W_normalization"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cd3ca50f",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "27619c4b",
   "metadata": {},
   "outputs": [],
   "source": [
    "#给定一个用户以及和他有相同兴趣的所有用户，找出前K个兴趣相似度最大的用户\n",
    "def findKUser(user2,relevance,K):\n",
    "    user2=np.array(user2)\n",
    "    relevance=np.array(relevance)\n",
    "    index=np.argsort(relevance)[-K:]\n",
    "    return user2[index],relevance[index]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "16d81971",
   "metadata": {},
   "outputs": [],
   "source": [
    "def Recall_func(item1,item2):\n",
    "    return len( list(set(item1).intersection(set(item2))) )/len(item2)\n",
    "def Precision_func(item1,item2):\n",
    "    return len( list(set(item1).intersection(set(item2))) )/len(item1)\n",
    "def Coverage_func(item1,item2):\n",
    "    return len(item1)/len(train['movieId'].unique())\n",
    "def Popularity_func(item1,df_movie_popularity):\n",
    "    popularity=0\n",
    "    n=0\n",
    "    for item in item1:\n",
    "        popularity=popularity+df_movie_popularity[df_movie_popularity['movieId']==item]['popularity'].values\n",
    "        n+=1\n",
    "    return popularity/n\n",
    "#给定对一个测试用户的推荐名单和该用户对名单上物品的感兴趣程度，挑选前K个最感兴趣的返回\n",
    "\n",
    "# def get_item1_recommendation(item1,df_movie_popularity,K):\n",
    "#     if len(item1)<=K:\n",
    "#         index1_K=item1\n",
    "#     else:\n",
    "\n",
    "#         movieId_lst=list(df_movie_popularity['movieId'])\n",
    "#         popularity_lst=list(df_movie_popularity['popularity'])\n",
    "\n",
    "#         #找出df_movie_popularity中对应item1部分，df_movie_popularity索引一定要连续\n",
    "#         index_lst=[]\n",
    "#         for i in range(len(item1)):\n",
    "#             movie=item1[i]\n",
    "#             index=movieId_lst.index(movie)\n",
    "#             index_lst.append(index)\n",
    "#         df_item1_popularity=df_movie_popularity.iloc[index_lst].reset_index(drop=True)   \n",
    "\n",
    "#         #从df_item1_popularity中找出前K个用户最感兴趣的电影\n",
    "#         item1_popularity=list(df_item1_popularity['popularity'])\n",
    "#         index1=np.argsort(item1_popularity)[-K:]\n",
    "#         index1_K=list(df_item1_popularity.iloc[index1]['movieId'])\n",
    "    \n",
    "#     return index1_K\n",
    "\n",
    "def get_K2_item1(rank,K2):\n",
    "    if len(rank.values())<=K2:\n",
    "        K2_item1=list(rank.keys())\n",
    "        \n",
    "    else:\n",
    "        rank_keys=list(rank.keys())\n",
    "        rank_values=list(rank.values())\n",
    "        index=list(np.argsort(rank_values)[-K2:])\n",
    "        K2_item1=[]\n",
    "        for i in range(len(index)):\n",
    "            K2_item1.append(rank_keys[index[i]])\n",
    "        \n",
    "    return K2_item1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "76b27ec5",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "bc27ae53",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "无法对用户198做出推荐，因为训练集中没有与其兴趣相近的用户\n",
      "无法对用户244做出推荐，因为训练集中没有与其兴趣相近的用户\n",
      "无法对用户264做出推荐，因为训练集中没有与其兴趣相近的用户\n",
      "无法对用户398做出推荐，因为训练集中没有与其兴趣相近的用户\n",
      "覆盖率为0.258233\n",
      "召回率为0.270670\n",
      "准确率为0.063556\n",
      "平均流行度为43.509366\n",
      "____________\n",
      "运行时间为43.633481\n"
     ]
    }
   ],
   "source": [
    "start=time.time()\n",
    "\n",
    "Recall=0\n",
    "Precision=0\n",
    "Popularity=0\n",
    "N=1\n",
    "Item1=set()       #最终推荐物品名单\n",
    "Item2=set()       #测试集用户的行为名单\n",
    "K1=20              #K近邻\n",
    "K2=50             #每个用户的推荐数目\n",
    "for user, result in test.groupby('userId'):\n",
    "    '''\n",
    "    对测试集每一个user，先计算出训练集给出的推荐清单item1，再根据user在测试集中的行为得到item2，得到相关指标\n",
    "    '''\n",
    "    \n",
    "    obj_user=user       #目标用户id\n",
    "    rank={}             #用来存储推荐名单的字典\n",
    "    result=pd.DataFrame(result)  #result的movieId列即为item2\n",
    "    item2=result['movieId']        #获取测试集的用户行为\n",
    "    \n",
    "\n",
    "    df_W_obj_user=df_W[df_W['user1']==obj_user]    #获取目标用户与其他用户的兴趣度矩阵部分，即W矩阵的某一行  \n",
    "    if df_W_obj_user.shape[0]==0:  #训练集没有与这个用户存在共同行为的用户\n",
    "        print(\"无法对用户\"+str(obj_user)+\"做出推荐，因为训练集中没有与其兴趣相近的用户\")\n",
    "        continue\n",
    "    else:\n",
    "        K_user,K_relevance=findKUser(df_W_obj_user['user2'],df_W_obj_user['relevance'],K1)    #第一个参数是与目标用户具有相关兴趣的所有用户，第二个参数是对应的相关程度\n",
    "    \n",
    "    df_obj_user=train[train['userId']==obj_user]   #目标用户在训练集中的行为\n",
    "    \n",
    "    index=0\n",
    "    for relevant_user in K_user:   #对前K个兴趣度最大的用户，遍历他们的行为，选择没有在目标用户中出现过的\n",
    "        df_relevant_user=train[train['userId']==relevant_user]       #获取这K个近邻用户的训练集数据\n",
    "        \n",
    "        for otherUser_item in df_relevant_user['movieId']:          #获取近邻用户的产生行为的物品\n",
    "            if otherUser_item in set(df_obj_user['movieId']): #如果这个物品出现在了目标用户的训练集中，继续遍历下一个物品\n",
    "                continue\n",
    "            else:             #将该物品加入rank中，更新咪表用户对该商品的兴趣度\n",
    "                if otherUser_item not in rank.keys():\n",
    "                    rank[otherUser_item]=0\n",
    "                rank[otherUser_item]+=K_relevance[index]*1\n",
    "        index+=1\n",
    "        \n",
    "    if len(rank.keys())==0:\n",
    "        print(\"无法对用户\"+str(obj_user)+\"做出推荐，因为训练集中与其兴趣相近的用户所作用的物品均被其作用过\")\n",
    "        continue\n",
    "        \n",
    "    #print(rank)  \n",
    "    #rank存储了每一个测试集中的目标用户，训练集对他们做出的推荐名单及他们对物品的兴趣\n",
    "    item2=list(item2)\n",
    "    #item1=list(rank.keys())\n",
    "    item1=get_K2_item1(rank,K2)\n",
    "    Item1=Item1.union(set(item1))\n",
    "    Item2=Item2.union(set(item2))\n",
    "    \n",
    "    popularity=Popularity_func(item1,df_movie_popularity)\n",
    "    recall=Recall_func(item1,item2)\n",
    "    precision=Precision_func(item1,item2)\n",
    "\n",
    "    \n",
    "    Popularity=(N-1)*Popularity/N + popularity/N\n",
    "    Recall=(N-1)*Recall/N + recall/N\n",
    "    Precision=(N-1)*Precision/N + precision/N\n",
    "    N+=1\n",
    "    \n",
    "Coverage=Coverage_func(Item1,Item2)   \n",
    "print(\"覆盖率为%f\"%Coverage)\n",
    "print(\"召回率为%f\"%Recall)  \n",
    "print(\"准确率为%f\"%Precision)\n",
    "print(\"平均流行度为%f\"%Popularity)\n",
    "        \n",
    "    #item1=由训练集给出的user的推荐清单\n",
    "    #根据item1和item2得到相关指标\n",
    "end=time.time()\n",
    "print(\"____________\")\n",
    "print(\"运行时间为%f\"%(end-start))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "da50f87d",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "无法对用户230做出推荐，因为训练集中没有与其兴趣相近的用户\n",
      "无法对用户281做出推荐，因为训练集中没有与其兴趣相近的用户\n",
      "K1=5\n",
      "无法对用户230做出推荐，因为训练集中没有与其兴趣相近的用户\n",
      "无法对用户281做出推荐，因为训练集中没有与其兴趣相近的用户\n",
      "K1=10\n",
      "无法对用户230做出推荐，因为训练集中没有与其兴趣相近的用户\n",
      "无法对用户281做出推荐，因为训练集中没有与其兴趣相近的用户\n",
      "K1=20\n",
      "无法对用户230做出推荐，因为训练集中没有与其兴趣相近的用户\n",
      "无法对用户281做出推荐，因为训练集中没有与其兴趣相近的用户\n",
      "K1=40\n",
      "无法对用户230做出推荐，因为训练集中没有与其兴趣相近的用户\n",
      "无法对用户281做出推荐，因为训练集中没有与其兴趣相近的用户\n",
      "K1=80\n",
      "无法对用户230做出推荐，因为训练集中没有与其兴趣相近的用户\n",
      "无法对用户281做出推荐，因为训练集中没有与其兴趣相近的用户\n",
      "K1=160\n",
      "用时：534.519825秒\n"
     ]
    }
   ],
   "source": [
    "start=time.time()\n",
    "K2=100\n",
    "Result_dict={}\n",
    "for K1 in [5,10,20,40,80,160]:\n",
    "    Result_dict[K1]=[]\n",
    "    \n",
    "    Recall=0\n",
    "    Precision=0\n",
    "    Popularity=0\n",
    "    N=1\n",
    "    Item1=set()       #最终推荐物品名单\n",
    "    Item2=set()       #测试集用户的行为名单\n",
    "    for user, result in test.groupby('userId'):\n",
    "        '''\n",
    "        对测试集每一个user，先计算出训练集给出的推荐清单item1，再根据user在测试集中的行为得到item2，得到相关指标\n",
    "        '''\n",
    "\n",
    "        obj_user=user       #目标用户id\n",
    "        rank={}             #用来存储推荐名单的字典\n",
    "        result=pd.DataFrame(result)  #result的movieId列即为item2\n",
    "        item2=result['movieId']        #获取测试集的用户行为\n",
    "\n",
    "\n",
    "        df_W_obj_user=df_W[df_W['user1']==obj_user]    #获取目标用户与其他用户的兴趣度矩阵部分，即W矩阵的某一行  \n",
    "        if df_W_obj_user.shape[0]==0:  #训练集没有与这个用户存在共同行为的用户\n",
    "            print(\"无法对用户\"+str(obj_user)+\"做出推荐，因为训练集中没有与其兴趣相近的用户\")\n",
    "            continue\n",
    "        else:\n",
    "            K_user,K_relevance=findKUser(df_W_obj_user['user2'],df_W_obj_user['relevance'],K1)\n",
    "\n",
    "        df_obj_user=train[train['userId']==obj_user]   #目标用户在训练集中的行为\n",
    "\n",
    "        index=0\n",
    "        for relevant_user in K_user:   #对前K个兴趣度最大的用户，遍历他们的行为，选择没有在目标用户中出现过的\n",
    "            df_relevant_user=train[train['userId']==relevant_user]       #获取这K个近邻用户的训练集数据\n",
    "\n",
    "            for otherUser_item in df_relevant_user['movieId']:          #获取近邻用户的产生行为的物品\n",
    "                if otherUser_item in set(df_obj_user['movieId']): #如果这个物品出现在了目标用户的训练集中，继续遍历下一个物品\n",
    "                    continue\n",
    "                else:             #将该物品加入rank中，更新咪表用户对该商品的兴趣度\n",
    "                    if otherUser_item not in rank.keys():\n",
    "                        rank[otherUser_item]=0\n",
    "                    rank[otherUser_item]+=K_relevance[index]*1\n",
    "            index+=1\n",
    "\n",
    "        if len(rank.keys())==0:\n",
    "            print(\"无法对用户\"+str(obj_user)+\"做出推荐，因为训练集中与其兴趣相近的用户所作用的物品均被其作用过\")\n",
    "            continue\n",
    "\n",
    "        #print(rank)  \n",
    "        #rank存储了每一个测试集中的目标用户，训练集对他们做出的推荐名单及他们对物品的兴趣\n",
    "        item2=list(item2)\n",
    "        item1=list(rank.keys())\n",
    "        #改动\n",
    "        item1=get_K2_item1(rank,K2)  #在原始item1中，根据目标用户对item的不同感兴趣程度（rank的取值）来挑选前K个最感兴趣的\n",
    "        Item1=Item1.union(set(item1))\n",
    "        Item2=Item2.union(set(item2))\n",
    "\n",
    "        popularity=Popularity_func(item1,df_movie_popularity)    #根据最终的item1计算这个推荐名单的平均流行度\n",
    "        recall=Recall_func(item1,item2)\n",
    "        precision=Precision_func(item1,item2)\n",
    "\n",
    "        Popularity=(N-1)*Popularity/N+popularity/N\n",
    "        Recall=(N-1)*Recall/N+recall/N\n",
    "        Precision=(N-1)*Precision/N+precision/N\n",
    "        N+=1\n",
    "\n",
    "    Coverage=Coverage_func(Item1,Item2)   \n",
    "    \n",
    "    Result_dict[K1].append(Recall)\n",
    "    Result_dict[K1].append(Precision)\n",
    "    Result_dict[K1].append(Coverage)\n",
    "    Result_dict[K1].append(Popularity)\n",
    "    \n",
    "    print(\"K1=%d\"%K1)\n",
    "    \n",
    "end=time.time()\n",
    "print(\"用时：%f秒\"%(-start+end))\n",
    "#     print(\"覆盖率为%f\"%Coverage)\n",
    "#     print(\"召回率为%f\"%Recall)  \n",
    "#     print(\"准确率为%f\"%Precision)\n",
    "#     print(\"平均流行度为%f\"%Popularity)\n",
    "\n",
    "        #item1=由训练集给出的user的推荐清单\n",
    "        #根据item1和item2得到相关指标\n",
    "\n",
    "#     print(\"____________\")\n",
    "#     print(\"运行时间为%f\"%(end-start))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "ac31e9a8",
   "metadata": {},
   "outputs": [],
   "source": [
    "K2_100=Result_dict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "ce22cbcc",
   "metadata": {},
   "outputs": [],
   "source": [
    "Result_sum={}\n",
    "for K2 in [25,50,75,100]:\n",
    "    for loc,index in enumerate(['Recall','Precision','Coverage','Popularity']):\n",
    "        if (K2,index) not in Result_sum:\n",
    "            Result_sum[(K2,index)]=[]\n",
    "        if K2==25:\n",
    "            for j in range(6):\n",
    "                Result_sum[(K2,index)].append(list(K2_25.values())[j][loc])\n",
    "        if K2==50:\n",
    "            for j in range(6):\n",
    "                Result_sum[(K2,index)].append(list(K2_50.values())[j][loc])\n",
    "        if K2==75:\n",
    "            for j in range(6):\n",
    "                Result_sum[(K2,index)].append(list(K2_75.values())[j][loc])\n",
    "        if K2==100:\n",
    "            for j in range(6):\n",
    "                Result_sum[(K2,index)].append(list(K2_100.values())[j][loc])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "309d4d0b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{(25, 'Recall'): [0.3111356342231092,\n",
       "  0.34789465482920817,\n",
       "  0.36649898191230385,\n",
       "  0.3435171480074795,\n",
       "  0.2997543348665014,\n",
       "  0.2778547917242118],\n",
       " (25, 'Precision'): [0.12141767183338284,\n",
       "  0.1337981651376152,\n",
       "  0.14040366972477086,\n",
       "  0.1382752293577983,\n",
       "  0.12924770642201833,\n",
       "  0.12088073394495402],\n",
       " (25, 'Coverage'): [0.2392001221187605,\n",
       "  0.17630896046405128,\n",
       "  0.1169287131735613,\n",
       "  0.0686918027782018,\n",
       "  0.04686307433979545,\n",
       "  0.03892535490764769],\n",
       " (25, 'Popularity'): [array([50.39224248]),\n",
       "  array([59.04154128]),\n",
       "  array([70.14972477]),\n",
       "  array([79.99023853]),\n",
       "  array([87.55574312]),\n",
       "  array([92.35493578])],\n",
       " (50, 'Recall'): [0.3839701118084793,\n",
       "  0.43251377904241173,\n",
       "  0.46254595965848444,\n",
       "  0.44532442284919965,\n",
       "  0.40929713765117764,\n",
       "  0.36501197679350617],\n",
       " (50, 'Precision'): [0.09206747516528435,\n",
       "  0.0964833203898164,\n",
       "  0.10091743119266067,\n",
       "  0.09996330275229347,\n",
       "  0.09442201834862395,\n",
       "  0.08693577981651375],\n",
       " (50, 'Coverage'): [0.33139978629216915,\n",
       "  0.2721721874522974,\n",
       "  0.1840940314455808,\n",
       "  0.11005953289574111,\n",
       "  0.07540833460540375,\n",
       "  0.0628911616547092],\n",
       " (50, 'Popularity'): [array([44.87145166]),\n",
       "  array([50.07440939]),\n",
       "  array([58.94011009]),\n",
       "  array([67.65288073]),\n",
       "  array([73.27236697]),\n",
       "  array([77.49317431])],\n",
       " (75, 'Recall'): [0.4263819799420612,\n",
       "  0.4914230052768269,\n",
       "  0.5159840623704898,\n",
       "  0.5029104174397058,\n",
       "  0.4639439061262956,\n",
       "  0.4284610164122],\n",
       " (75, 'Precision'): [0.07994232453710398,\n",
       "  0.07869881299551021,\n",
       "  0.08095478965203745,\n",
       "  0.07951070336391432,\n",
       "  0.07515596330275243,\n",
       "  0.07040978593272179],\n",
       " (75, 'Coverage'): [0.3927644634406961,\n",
       "  0.34132193558235385,\n",
       "  0.2450007632422531,\n",
       "  0.1473057548465883,\n",
       "  0.09800030529690124,\n",
       "  0.08365135093878798],\n",
       " (75, 'Popularity'): [array([41.88863632]),\n",
       "  array([44.89830002]),\n",
       "  array([52.34841491]),\n",
       "  array([60.17719878]),\n",
       "  array([65.49037309]),\n",
       "  array([69.42059939])],\n",
       " (100, 'Recall'): [0.45070371713727825,\n",
       "  0.5189619271575283,\n",
       "  0.5626479040198559,\n",
       "  0.5413849289839522,\n",
       "  0.5112880370098452,\n",
       "  0.4715575670319483],\n",
       " (100, 'Precision'): [0.07280161389997185,\n",
       "  0.06789956472702015,\n",
       "  0.06931859341921509,\n",
       "  0.06743119266055059,\n",
       "  0.06464220183486247,\n",
       "  0.06033027522935779],\n",
       " (100, 'Coverage'): [0.4362692718668906,\n",
       "  0.3965806747061517,\n",
       "  0.292169134483285,\n",
       "  0.17676690581590596,\n",
       "  0.12272935429705388,\n",
       "  0.10227446191421156],\n",
       " (100, 'Popularity'): [array([40.21607702]),\n",
       "  array([41.71267658]),\n",
       "  array([47.75657072]),\n",
       "  array([54.89058716]),\n",
       "  array([60.13293578]),\n",
       "  array([63.71862385])]}"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Result_sum"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "ab901f1c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x24bb8c854c0>"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "plt.rcParams['font.sans-serif']=['SimHei']\n",
    "plt.rcParams['axes.unicode_minus'] = False\n",
    "for K2 in [25,50,75,100]:\n",
    "    y=Result_sum[(K2,'Recall')]\n",
    "    x=[5,10,20,40,80,160]\n",
    "    plt.plot(x,y,label='K2='+str(K2))\n",
    "    plt.xlabel(\"K近邻个数\")\n",
    "    plt.ylabel(\"Recall\")\n",
    "    plt.title(\"Recall\")\n",
    "plt.legend()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "c792de27",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x24bbb40f9a0>"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "for K2 in [25,50,75,100]:\n",
    "    y=Result_sum[(K2,'Precision')]\n",
    "    x=[5,10,20,40,80,160]\n",
    "    plt.plot(x,y,label='K2='+str(K2))\n",
    "    plt.xlabel(\"K近邻个数\")\n",
    "    plt.ylabel(\"Precision\")\n",
    "    plt.title(\"Precision\")\n",
    "plt.legend()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "4a5964d9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x24bbb4984f0>"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "for K2 in [25,50,75,100]:\n",
    "    y=Result_sum[(K2,'Coverage')]\n",
    "    x=[5,10,20,40,80,160]\n",
    "    plt.plot(x,y,label='K2='+str(K2))\n",
    "    plt.xlabel(\"K近邻个数\")\n",
    "    plt.ylabel(\"Coverage\")\n",
    "    plt.title(\"Coverage\")\n",
    "plt.legend()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "72c0b462",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x24bbb8306d0>"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "for K2 in [25,50,75,100]:\n",
    "    y=Result_sum[(K2,'Popularity')]\n",
    "    x=[5,10,20,40,80,160]\n",
    "    plt.plot(x,y,label='K2='+str(K2))\n",
    "    plt.xlabel(\"K近邻个数\")\n",
    "    plt.ylabel(\"Popularity\")\n",
    "    plt.title(\"Popularity\")\n",
    "plt.legend()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "351906fd",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
